July 2026

Because when one human starts talking to others how amusing his/her pets are, thats a sure sign of dementia.

Pet does not care what other pets do except things they make.

It's time to rethink this website.

Now page is a fucking stupid idea. How could pet get influenced with such human's crap?

Pet is enjoying summertime real life. Anyway, there's nobody left on the internet to talk with.

Looking at the long list of TLDs pet thinks it needs its own .meow TLD. And probably .nazi too.

Also, this make possible to share values directly across threads.

No.

Sharing values across threads means one thread must allocate block in other thread heap. This can't be done without synchronization and such sharing should be prohibited.

https://www.endoflineblog.com/functional-programming-from-first-principles-part-1-motivation

What the heck?

Mathematical definition of functions

...

  1. Each element of the domain is mapped to exactly one element of the codomain (never to zero elements, which is covered by totality already, but also not to more than one element). This condition is called univalency (“single-valueness”).

Is it pet got this stupid or their AI assistant went off the chain?

What about y = x2 or y = tg x ???

Closing this reading for now.

Yet another relevant bookmark https://blog.jaysmito.dev/blog/04-fast-lockfree-queues/

Nah, the terminology is awful.

Scope is better but still not correct.

TBD

Also, nullptr should define the same scope.

So,

shmem may point to any area, including thread-local, because in some places an existing pointer is used. So deep copies by default go to the same scope.

Also, this make possible to share values directly across threads.

Pet is revising PetWay memory model.

What humans invented by now:

And their execution model consists of:

Below are pet's ideas to make things lock-free.

All PetWay values should be thread-local. Which means allocators are thread-local. No locking at all. That's simply unnecessary.

For I/O bound stuff that's okay because tasks are thread-local and most apps are single-threaded.

Values can be shared.

Pet added share method to the basic interface. For integral values this method is unnecessary. No matter where values are stored, they can be freely moved around. share method is necessary for types that have allocated data. It allocates new block in a region defined by shmem argument and moves the data there.

Constructors also accept shmem argument (in ctor_arg structure). So values can be created directly in specific regions.

Each region may have its own allocator. Internally, all allocators are the same for now, just using thread and interprocess synchronization primitives for process-local and global shared memory respectively.

Interesting things happen when the data is about to be freed in other thread. As long as each thread has its own allocator, pw_free will figure out that the allocator is wrong and will abort the program.

As long as thread-local allocator is selected when shmem argument is nullptr, there's no way to share values directly with other threads.

Surely, one thread can give another a pointer to read the value, but modification will likely fail.

In PetLang the use of shmem will depend on the scope of variables. This should be transparent but the design is TBD.

Pet skimmed through all those lock-free linked list algorithms. They all look like a poor version of spinlock, no wonder the performance is still nonlinear.

The problem is that a thread cannot tell where other concurrent thread is running. If on the same CPU, then it must give up its quantum. Otherwise, spin around.

But spinning is not a good solution.

Meow! This evening pet has stumbled across an /ir/relevant blog post https://blog.haschek.at/2026/you-should-selfhost-your-mail.html

The relevant part is it's title. The content is rather not really.

Self-hosting email is close to the top of pet's to-do list, right below licking balls. Pet had experience with this in one of its past lives so it has a bit of knowledge.

Email is a technology of dinosaurs and this is the biggest problem. Dinosaurs were chained to castles where one castle used to host only one computer. Luckily, things have changed and now everyone has such a castle in its pocket, with much, much bigger computing power.

But dinosaurs did not change. The world became mobile but as you can't take Chicago out of the girl, you can't take chains out of dinos.

Pet is not chained. Pet's dream is to selfhost email on a couple of mobile devices.

But client-server model sucks, requiring a static IP address. If you move frequently, modifying MX record is a pain. This can be automated, but... There's a bigger problem: dinos still check PTR record.

Even in a relatively recent development, OpenSMTPD, in the mobile era, they implemented PTR check. Pet saw who, pet saw the patch, pet saw delightful comments.

Yuck!

Most mailing lists pet unsuccessfully tried to participate do PTR check. Very strictly.

Even GMail DOES NOT CHECK PTR! At least, it did not circa 2020 But you won't be able to communicate with Gmail users because all your emails will end up in spam folder, even if you correctly setup all those DKIM, SPF, PTR. GMail wants you to use GMail and nothing else.

So. If you want to self-host email and keep it working, you must seriously ask youself: why?

Why pet needs email? Only because old-school sites still exist and they want email to confirm registration. That's all. Yes, that's the only reason. Take away that old crap and pet does not need email at all!

Of course, pet is lying. It does need email, but just for another minor reason. That's why it is planning to run its own email server.

That's another point: the server.

Email servers were developed to serve thousands of users.

But pet is the only user.

You will be the only user.

Who else? Your family members? Your kids? Don't make pet laugh. Kids never trust parents, they will quickly find out you can read their messages and they won't use it. Never.

Nevertheless, running yet another server is cool. As a protocol, email is pretty good and If you make you server less restrictive, without DKIM/SPF/PTR crap, more organisms will be able to communicate with you.

And don't be afraid of spam. Pet published its email addresses but never seen any spam on its new domains. The only huge amount of spam came to one revived domain which means spammers are dinos and other old farts who just keep their Core2Duos still plugged in just because they are nice and warm.

Seriously, only friends know your email. If you want to publish it, publish another one. You own the whole server, at last.

Don't use catch-all address. Just reject crap. And require TLS.

GPT for spam filtering? Yuck! Yuck! Yuck!

Docker image? Yuck! Yuck! Yuck!

Learn! Educate yourself!

And, the most important thing for pets: they do need a VPS, but not for hosting anything on it. Just for static IP. Run everything at home via tunnels. Do not keep certificate keys on VPS. Don't let hosters to sniff your butt as AWS do.

Damn, this needs to go to meow section.

P.S. for the completeness:

https://blog.haschek.at/2023/ssh-based-comment-system.html is a cool idea but that organism missed one point: let real users upload their SSH keys. Filtering by IP sucks in terms of network neutrality.

No wonder pet sees no comments below any of his posts.

P.P.S.

If one sends a message from a selfhosted email server to another selfhosted email server over TLS, do they need email encryption?

Fuck, no! Unless they are morons and keep TLS keys on a VPS.

Pet has stumbled acrross a funny comment https://lobste.rs/s/ax914v/protecting_our_floss_commons_from_llms

Back when compilers were invented, did folks point out that a compiler uses more energy than does an assembler, and an optimising compiler uses even more? Did they complain that using a high-level language enabled a single programmer to produce what used to take a team? Did they complain about a ‘digital divide’ between those who could afford procuring and running high-level languages and those stuck with machine code?

LOL. Each high level language had a spark and they did not breed stupidity.

Besides, what I to expect from those who cannot even write sane crawler in the first place? It looks like they're unable to use their own AI for that.

Watching forums and social networks disappear pet gets more and more convinced that client-server model is the root of all evil. Every human has an incredible computing power in their pocket but they still cannot communicate without a third party.

Coding assistants are slowly melting their poor brains and they won't be able to desing anything better even by 2030. Matrix, Jitsi, and XMPP clients for mobile are best examples.

Pet had to move back to Thunderbird.

ClawsMail is good, but gmail fucked up everything with OAuth.

Fuck gmail.

There's only a few accounts left from past lives and it's time to setup redirects and forget about gmail for good.

June 2026

Wandering around pet passed bluesky many times without noticing. Mainly because someone told pet they simply collected email addresses without doing actual registration. Pet supposes they tried to raise funds by selling collected emails to spammers.

Anyway, as pet sees more and more bluesky mentions on fediverse, pet gave it a try. Guess what? It did not work! Only tons of CORS-related messages in the console log.

Pet is not surprised.

You never hire good developers with such funding.

Pet wonders why human normies are so fond of Instagram.

Pet would get it if they were perverts like Fediverse users.

No. They are normies, but from pet's perspective the Instagram is the source of child erotic and even porno.

Because every picture of pet is a child porno because on every pic:

They, humans, even not ashamed to post nude kitties.

Instagram should be destroyed.

Every line of code committed by Meta and all its subsidiaries to open source projects should be considered pet abuse and therefore reverted.

All humans working or worked for Meta and all its subsidiaries are bastards and must be exterminated.

All humans used Meta products should wash off that shame with ten years of correctional labor.

Pet knows what to do!

Tunnels. That won't be open source except the basic ip-tcp and ip-udp. You know why: 5% of humans can write that by themselves, the rest 95% are bastards and do not deserve it.

Licking balls

0.4.1 release of pet codebase. Not including pw-curl, pet is too busy at the moment

PetWay includes CGI helpers pet used for its contact page. Pet will show the code someday, but the code without an article is pretty useless and pet is too busy to write an article on CGI in C. And lazy.

PetMachine is the work in progress, it's on hold for now.

Something is happening with pet's favorite text editor. When internet connection goes down, it hangs momentarily.

They after pet, bastard humans!

Pet needs a clean system.

When pet was checking internet connection it opened some Fosdem video. Why Fosdem? Pet does not know. It just needed something to check youtube works without pops and clicks. And this video in the background made pet really sad. Who are all those humans? They are fucking telling about their technological achievements while pet is trying to connect one world to another like it's 1984 outside. All they with their fucking businesses fed those corpos that in turn fed their governments. It does not actually matter who built those walls. They all did.

Fuck humans. 95% of them to be precise who are true bastards.

Pet did it and made a few humans happy. The setup is quite interesting:

One thing that troubles pet is tunnels. They block it regularily and pet needs to work out something. Of course, there's a plenty of existing solutions but their problem is they are all known.

Pet freaked out a few humans, asking for setting up an entry point, and only one agreed to help realizing that beloved country may easily roll down to shit.

Thank you, brave true human!

May 2026

Pet has to put PetWay on hold and help kitties from shit-tier countries to break free.

Pet wanted to implement tasks in the next PetWay release, but given the amount of changes and bugfixes it will be an interim release. Yet on hold. Poor kitties first.

Pet stepped into its own crap again:

char* s = "Lorem ipsum dolor sit amet";
PwValue a = PW_STATIC_STRING(s);
PwValue b = PwStaticString(s);

a is not equal to b, it's just eight chars long: "Lorem ip". On 32-bit systems it would be four chars.

That's because PW_STATIC_STRING uses sizeof(initializer). Merging both macros and use strlen for literal strings is silly too.

Pet needed to check is the initializer is a string literal, and here's an elegant solution:

.char_ptr = initializer "\0"

That won't work for pointers and that's exactly what pet needed.

Actually, pet placed this check into sizeof:

.integral_length = sizeof(__VA_ARGS__ "\0") - 2,  \

Pet stepped into CGI again. It's sticky and stinky but it gave PetWay lots of improvements.

Transactions, that's what humans need to learn. Given that that's they who invented that.

Pet is a moron sometimes (most of, actually).

Probably broke shring for a couple days.

Meow.

How shitty that golang is.

It does not like

process_file(
    filename,
    template,
    true
)

It needs exactly

process_file(
    filename,
    template,
    true)

Yay, pet finished revising (again) Status at last.

Exception kind of Status sucked as a concept because the logic was weird. Pet separated it into Exception type, a subtype of Struct with Status as a mixin.

Updated MYAW passed tests.

Pet does not like this solution and considers it temporary. But it's okay for now because it's stable and more or less clear. It will be revised many times, probably.

Now, pet gets back to exceptions handling in PetMachine.

April 2026

Pet never liked RaspberryPi because of shitty hardware. Of course its pioneer role can't be diminished, but other teams quickly outperformed it and left far behind.

Pet would never get RPi intentionally, but it was donated a few and could not refuse.

Today pet tried to bring hostapd up on a RPi4. Pet has rich experience with cheap wifi, only a few work as access point. The only board where AP was not supported at all was OrangePi Zero. Pet thinks AllWInner forced them to buy that 819 crap along with H3 chips, that's the only explanation. And that was their only fuckup. The next one, Orange PI R1 had a decent wifi based on Realtek chip. Not mentioning modern boards where wifi works like a charm.

Well, what pet has got on RPi4? Here's what:

hostapd[1500]: Failed to set beacon parameters
wlan0: Could not connect to kernel driver
Interface initialization failed
wlan0: interface state COUNTRY_UPDATE->DISABLED
wlan0: AP-DISABLED
wlan0: Unable to setup interface.
wlan0: interface state DISABLED->DISABLED
wlan0: AP-DISABLED
wlan0: CTRL-EVENT-TERMINATING
hostapd_free_hapd_data: Interface wlan0 wasn't started

WTF? Pet glanced at search results and found a few people fixed that changing channel 11 to 6. Well, pet used channel 11 too and tried the same.

That did not help.

Okay, what's about rfkill?

ID TYPE      DEVICE      SOFT      HARD
0 bluetooth hci0     blocked unblocked
1 wlan      phy0     blocked unblocked

Arrgh, meow! Okay,

rfkill unblock wlan

And it worked! Even with channel 11.

But where to put this rfkill in this fucking systemd? Yes, pet should have moved to Void Linux but there's a lot of other urgent things to do besides licking balls which is mandatory.

Okay, let's customize the unit. First, copy it:

cp /lib/systemd/system/hostapd.service /etc/systemd/system/

Open it, and... Fuck! What the fuck?

Type=forking
ExecStart=/usr/sbin/hostapd -B -P /run/hostapd.pid $DAEMON_OPTS ${DAEMON_CONF}

Those Raspbian humans are in love with that fucking systemd for more than a decade and they still do not know in which hole they should insert their cocks?

Let's fix that:

Type=simple
ExecStart=/usr/sbin/hostapd $DAEMON_OPTS ${DAEMON_CONF}

And add what we need:

ExecStartPre=-/usr/sbin/rfkill unblock wlan

That's all, pets. Guess you know how to re-enable the unit. Reboot safely.

Pet is working on synchronization primitives.

Tasks are such primitives too: they are awaitable.

The implementation is a bit hacky at the moment, but Task and ChldTasks primitives can do without memory allocation at all.

Web rings are cool, but the way they are managed is devastating.

From pet's perspective this should be like this:

This way a user would always be able to make full circle.

Transactions, that's what humans need to learn. Given that that's they who invented that.

Revised Status type. Added kind field that clearly distinguishes simple statuses from exceptions.

Why not using subtypes?

Status type is special. When used in its simplest form (BaseError and SystemError kinds) it should do without memory allocation.

Meantime Status is a subype of Struct but memory is allocated only if its kind is Exception.

Subtyping is possible. Actually, MYAW does this already. Revised code should make it simpler, pet hopes.

Statuses of Exception kind can be chained. This is necessary for PetLang.

Pet gets back to PetMachine.

It's like a lizard brain that exposes human's nature, the remains of human brain make pet write smelly code without a reason.

It's damn hard to keep myself in paws and do things right.

Pet is in process of revising PetWay Status type. It's an interesting type, and pet almost forgot all its details. That's bad. Things must be simple. Pet's neural network will be improved only in the next life if pet will be in luck.

Okay, pet moved to Claws-Mail.

Pet went through all frustrations and configuration options and finally reconciled itself with the humans reality.

Pet managed to make it from fucking lame down to a bit lame, as all good free projects. After all, that's just a matter of taste.

Finally, RSS is a huge argument:

How comes thunderbird stuck and pet missed a few emails?

Pet is trying claws-mail.

Fucking gmail with its oauth. Nothing works. -- pet had to add self to users ot that oauth app. Fucking idiots. Including pet who's using crap from fucking idiots.

Humans drag pet to caves.

Fuck humans!

Basically, pet needs to setup redirect and forget about google for good.

Okay, selfhosting email again. Previous attempt did not work because... because... pet does not remember. Probably because of inability to setup a PTR record on a shitty VPS hosting. And thanks to one idiot who enabled PTR checking by default in opensmtpd.

Humans used to say selfhosted email works okay only with other selfhosted servers.

Fuck, no!

Even gmail is not this restrictive. Yes, messages fall to spam folder but they aren't bounced.

Email is dead, actually. For pet, at least.

Pet is happy to know via https://baccyflap.com/ that Android will become a locked-down platform in 130 days.

Pet always wanted to dive into mobile development but it was too busy (with you know what) or, honestly, lazy.

Maybe that's good? Why fight for crap? All pet needs is an LTE modem attached to some Nano/Orange Pi Zero and a WiFi terminal based on something pet is able to reflash.

Humans go back to caves!

Pet is working on PetMachine.

Two stacks, as in Forth, multiple tasks, the logic is pretty simple.

But the major difference is hierarchial structure of tasks. Initially this was inspired by https://vorpus.org/blog/notes-on-structured-concurrency-or-go-statement-considered-harmful/ but nurseries look weird. Not because the concept is bad, no. They are weird because of one implicit thing: blocking on context exit.

Yes, that looks the only point that makes a good idea weird.

Nobody is against a process tree concept, right? But what if a parent process would implicitly block awaiting termination of all children?

That would be weirdest thing humans ever invented.

Processes have SIGCHILD. Trio has error propagation.

Pet borrows these two ideas: hierarchy and error propagation. Pet rejects nurseries.

Having parent-child relationships, rules are simple for tasks:

If an exception from a child may arrive at any time, this is troublesome. Consider the following example (yes, this is PetLang syntax with objective description after try):

try "Start all necessary tasks"
{
    create_task(START_NOW, ...)
    create_task(START_LATER, ...)
}
except TaskException {
    // WTF ???
}

try "Doing our own job"
{
    while (true) {
        // ...
    }
}
except TaskException {
    // ignore, re-raise, print, whatever
}

The problem with this code is that a TaskException may occur between except TaskException and try "Doing our own job". How to handle them correctly?

A solution could be similar to signals: disable_exceptions and enable_exceptions, but pet thinks that's cumbersome and error prone.

Pet's solution:

Well, that's too implicit, but that's what Pet would expect from a code like this:

task_1 = create_task(START_NOW, ...);
task_2 = create_task(START_LATER, ...);

// exceptions from children aren't propagated yet

try "Doing our own job" {

    // here's the point where exceptions from children may emerge

    while (true) {
        // ...
    }
} except TaskException {
    // ignore, re-raise, print, whatever
}

Also, propagation should be disabled in exception handlers, i.e. in except and finally blocks.

Pet is playing with Void Linux.

Pet loves it!

It seems pet will meow "Farewell, Devuan" very soon.

It seems peTux is not necessary for now.

Whatever pet tries to implement it runs into the lack of coroutines in C.

Humans would say use C++.

No. Pet does not want to step into this.

Go, with all its flaws, is simply great when it's about goroutines. No function coloring with async, everything is plain and simple: go.

This is at the expence of implementing their own code generator.

Pet can't afford that. Pet needs a simpler solution.

Forth, the greatest language with the ugliest syntax gave pet a hint: threaded code.

Well, not exactly threaded, but what if a function would be a sequence of bool (*func)() pointers? It would need a machine to execute, but that would not be an exact virtual machine because it would deal with addresses, not opcodes. Each function would represent a noninterruptible piece and could be implemented in C.

Pet gets down to the PetLang spec.

Pet just thought: each humans' attempt to create a social network breaks against their sins. Basically, on the one hand primates tend to hierarchies and the client-server model perfectly reflects that. But on the other hand, as "The Pastor is The Shepherd of God's Flock", clients are just a flock.

Can pets form a flock? Don't make pet laugh.

No matter who creates a social network following this model, they are doomed.

Federation could be a rescue but that did not help humans. They found de-federation wars is a perfect entertainment. That model is not acceptable for pets.

So what's then?

Anarchy, obviously.

Pet thinks it should add an RSS in its site generator.

Pet is now happy Deluge user.

March 2026

Programming in C for pets: four chapters are meowed, pet just needs to write them down in humanspeak.

Pet marked BlueDwarf. That was funny experience. Pet hasn't seen such an arrogant human before.

March 2026 is running out and pet hasn't written a single line of code yet.

Has not?

It has!

Just forgot. Subtitle extraction with libavformat to learn humanspeak and for citations!

Pet is trying to be useful for its masters. Lots of things to do. Won't tell.

Sometimes licking balls and thinking.

December 2025

PetWay, MYAW, and pw-curl 0.4.0 are out.

Revising pw-curl and PetWay.

The vast majority of programming languages seem to be stemmed from right to left handwriting.

Especially in assignments.

Which comes from math.

Arabs were great mathematicians.

The shape of their digits comes from Allah.

Well, Pet's code is a bit messy in this regard and needs some cleaning.

Also, Pet did some obvious simplifications.

September 2025

how to move from github

Git sucks. For every basic action, a bit more advanced than clone/commit/push, pet has to look into the documentation. But in the most basic cases git help and man pages suck too, and pet has to use a search engine to find out all those tricks and special characters like ^ for particular use cases.

Pet does not trust git developers because of their way of thinking. Sadly, the same humans participate in Linux kernel development.

Mercurial is more pet friendly. Pet types commands almost intuitively and they run as expected. That's a real magic.

Pet does not write too much, it tries to write less. So it makes sense to keep the source code right here.

about karmic fate

Unlike its ancestor pet is not happy with its main activities. But it seems to be doomed to repeat them.

How to break the circle?

Forced reincarnation could be a way out, but only as the last resort and success is not guaranteed. Pet feels it must do something else.

But what?

What?

August 2025

July 2025

March 2025

Pet's path to tilde.club:

Previously

Licking balls.